0%

py
py
  • 数据类型
    • 字符串
      • 字符编码:
      • 操作符
        • ch1+ch2生成字符串 "ch1ch2"
      • 方法
        • 截去头尾:str.strip([char])
          • 从str的头尾移除[char]中包含的字符,str本身不变 返回截取后的子串
          • [char]参数缺省表示截去空字符
      • 非转义前缀:s=r"stri\ng" 不识别转义。 所以r"stri\ng"="stri\\ng"
    • 列表和元组
      • 列表 list
        • 定义并初始化:A[ , ]
          • 方括号括起来,逗号隔开
          • 元素构成:任何类型 包括list本身。故可有二维组A[i][j]。
        • 访问:类数组:A[i]
          • num可为负:name[-1]是最后一个 [-2]是倒数第二个。
        • 操作函数:
          • 元素数:len(A) 返回元素数。
          • 追加:A.append(α) 追加元素α于A的末尾。
          • 插入:A.insert(i,α) 插入α到A[i]处。
          • 删除:A.pop(num) 删除A[i]处的元素。 i缺省表示删除末尾元素。
          • 替换:直接赋值
      • 元组 tuple
        • 定义并初始化:A( , )
          • 圆括号括起来,逗号隔开
          • 元素构成:任何,包括列表和元组。
        • 与list区别:元素不可变
        • 歧义:t=(1)
          • t未定义成有一个元素的元组,而是定义为整数1。
          • 定义成元组:t(1,)
    • 集合和字典
      • 集合set
        • 意义:等同于数学集合:无序,互斥
        • 定义
          • 【S={a,b,c}】直接指定集合元素
          • 【 S=set(A) 】定义集合S其内容为列表或元组A中无重的部分
        • 操作函数:
          • 添加: 【S. add(key) 】将key元素添加到集合S中
          • 删除: 【S.remove(key)】将key元素从S中删去
          • etc.
        • 数学运算:
          • 取交 &
          • 取并 |
      • 字典dict
        • 意义: 表示满射map
        • 初始化
          • 大括号:【d={"bob":98 , "tom" : 82} 】直接给出映射关系,定义域和值域
          • dict()
            • d=dict(zip(Key,Value)) 】映射列表(元组),Key -> Value 当元素数不一致,按少的进行。
            • d=dict(K=V)】 K 和 V都是标识符,找不到K自动创建。
        • 操作函数
          • 取值:【d.get(_key, _value)】 返回d中_key对应的value,如果_key不存在,返回_value
            • _value缺省,_key不存在返回None
          • 删除【d.pop(key)】
          • 取值域:返回一元组 【d.values()】
          • 取映射对:返回二元组 【d.items()】
            • 组中每个元素是(key ,value)
          • etc.
        • 操作符
          • d[key]=value 更改(或初次添加)key的值
          • _key in d 返回布尔类型,_key在d的定义域返回1
        • 对比双list:查找快,空间占用大
    • 类型判断函数:isinstance( object, classinfo)
      • object是变量,classinfo是类型名,相同返回1
      • 基本类型:
        • int float bool complex
        • str
        • list tuple
        • set dict
  • 条件
    • if ( ) :
      • 注意冒号
      • 语句块不需要大括号,而是通过缩进控制
    • elif():
      • 注意冒号
      • 表示else if (): 简写的作用是减少缩进
      • 可以有多个
    • else 相当于switch的default 。
  • 循环
    • 【 for x in list/tuple:】 创建变量x,按顺序遍历list/tuple中的每个元素一次,执行语句块
      • 注意冒号
      • 类似c++ for(x:{1,2,5,8,3})类型的循环
      • 列生成函数:range(n) 返回一个列 0,1,.... ,n-1
        • for(int i=0;i<n;++i){ 平替成:for i in range(n) :
    • 【while () :】同c while
    • 支持break和continue
  • 函数
    • 定义
      • 【def fun ( 形参表) : 】缩进块里写函数体。
      • 不限返回类型
    • 参数检查:
      • pass
    • 空函数体:【pass】
      • 作为占位符,避免报错。c的什么都不做函数有【;】表示空语句。
    • 各类参数
      • 位置参数:同c
      • 默认参数:同c++,第一个默认值后都需默认值
      • 可变参数:【def fun( * args):】
        • 优点:传入元素数未知
        • 本质:构造元组
          • 【def f ( *args ):】 构造一个元组args 其元素是传入的元素。
        • 向可变参数函数传入一个组:调用时:【 f( *list)】实参list前加*。
          • 此用法可适用给各种函数传参 eg >>>det test(x , y) ... pass >>>lis[1,2] >>>test(*lis)
      • 关键字参数:【def fun (**kw)】//kw是关键字缩写
        • 本质:构造字典
        • 调用方法:
          • fun(city="beijing" , password=123456)
          • 必须提供变量的名字
        • 优点:提供不同类的参数传入
        • 可变和关键字异同:
          • 同:提供方便 传入0到无穷多的参数
          • 异:
            • 可变->元组 同类参数,没有名字 例如求和函数
            • 关键字->字典 有名字的不同类参数 例如学生信息登记函数
        • 默认值:pass
      • 命名关键字参数
        • 优点:忽略传入参数的顺序
        • 实现方法:提供传入参数的名字
          • fun("Tom",24, city="Beijing" , password=123)
            • 其中tom和24是位置参数,但是city password两个参数是命名关键字参数,可以顺序互换
        • 歧义:位置参数or关键字参数?
          • fun("tom", 24 ,city ,password)中,没有区分哪个是关键字哪个是位置
          • 解决:fun(name, year , *,city ,password) 分隔记号* 之后的都是位置参数
      • 参数组合顺序:必选,默认,关键字,命名关键字
        • 用tuple和dict调用:fun(*args,**kw)//前面元组args中是没名字的参数,后面字典kw中是有名字的参数
    • 高阶函数:
      • map/reduce :映射/归并in
        • map
          • 映射函数map(fun , Iterable)
          • Iterable是定义域;fun是映射关系;返回值域,性质为同类Iterable
        • reduce
          • 简化归并 reduce(fun , Iterable )
          • fun是二元运算函数,两个自变量性质一致,返回值和自变量性质一致
          • 功能:用fun将Iterable的前两个元素归并成一个,得到新列。再归并新列的前两个元素,反复操作,reduce返回单个元素。
        • 模块:functools
      • filter :筛选
        • filter( fun, Iterable)
        • fun返回bool。顺次用fun处理Iterable的元素,0扔掉1保留,生成新Iterable。
      • sorted :排序
        • sorted( Iterable , * , cmp , key , reverse)
        • 后三是可选的命名关键字参数
        • cmp是比较函数
          • 传入两个组元素,返回值:正前者大 负后者大 零一样大。描述组元素序关系
        • key是值函数,传入一个组元素 返回可比较值。类似cmp,将组元素抽象为可比较的值。
        • reverse 是布尔值,缺省为零,升序。为1则降序。
    • 返回函数
      • 函数返回值可以是函数
      • 闭包(closure)
        • 返回函数的函数
        • 形式特点:分层传参
        • 本质:通过外层函数参数生成不同的函数
          • eg1
            • 本例子外层函数可以生成不同的直线函数 line(x)
          • eg2
            • 不用闭包
              • print出来333
            • 用闭包
              • 出来123
        • 只有外层函数有变量,是假的闭包
          • 输出999
          • f的状态可变,取决于调用f时i的状态
          • ??
        • 优点:
          • 提高复用
            • eg1不管生成几个一次函数,都可用
          • 保存函数运行环境
            • 本质上是生成的函数可以有不同状态,对应于传入不同的参数
              • eg2可固定循环变量i的值
    • 匿名函数【 lambda arg : 表达式】
      • 没有名字
      • 表达式的值就是返回值
      • 应用例子:
      • 仅调用一次的函数不需要名字,它只需要是个代码块,但是要把代码块的性质转为函数,以供传入其他现成函数。
    • 装饰器(decorator)
      • 修饰器是一个函数
      • 作用
        • 不改变被修饰函数本身的情况下实现附加功能(如打印日志),所以修饰器要以被修饰函数作为参数(之一)
      • 修饰的本质
        • 把原函数名重定向到另一个函数。后者模拟了原函数的功能同时附加了额外的功能。
        • 最终func被模拟成了simulation函数,外层嵌套都是分层传参需求的结果。
        • 而decorator()(func)中 decorator()的性质是函数,所以才可以加(func)参数。加入func参数后返回模拟函数,用以接受func真实的参数
      • 定义
        • 一般的
        • 为了使simulation的签名与func相同,需要将simulation修饰。 40行是内建的签名仿造函数,表示将simulation的签名仿成func
          • 内部类似 simulation.__name__=func.__name__
      • 调用方法
        • 函数定义前@_name_of_decorator(*args , **kw) (传的是修饰器需要的参数,不包含被修饰函数)
          • @_name_of_decorator(*args , **kw)是 func=_name_of_decorator(*args , **kw)(func)的语法糖
    • 偏函数(partial function) 【 fun2=functools.partial( fun , 指定的参数)】
      • 是一个函数
      • 确定原函数某些参数的默认值,返回新函数
      • eg. int是字符转整数函数,base是将字符视为数的基
  • 高级特性
    • 切片操作符【 L [ begin: end: step]】
      • L:一个list/tuple //字符串亦可看成list
      • 返回一个list/tuple 内容为 以L[begin]开始,每step中取一个 ,直到L[end] 结束且左闭右开
      • 三个参支持负
      • 缺省:begin=0 end=end step=1
        • eg
          • L[:3] 取前三个元素L0、1、2
          • L[-3:] 取倒数三个元素L-3、-2、-1
          • L[:] 不动抄下来
    • 迭代(Iteration)【for ___ in ___】
      • 一元组: 同for循环
        • 一元组下标生成:enumerate(L)
          • for i , value in enumerate( L):
      • 二元组:for x, y ,z in [(1,2,9),(3,4,9),(5,6,7)]:
      • 字典:for id in d:
        • 默认迭代对象是字典的key定义域,id是任意标识符
        • 迭代值域:for id in d.value
      • 字符串: for id in str:
      • 可迭代对象判断:
        • collections模块的 Iterable类型:
    • 列表生成式 【 [ f(x) for x in __ ] 】
      • 相当于map;但效率上map快
      • 用于生成列表,不能生成元组。
      • 【L=[f(x) for x in B] 】迭代B迭代指标为x,生成f(x)为元素的列表。
      • 附条件生成
        • 【 f (x) for x in B if (is(x)) 】 is(x) 为真时生成元素
      • 多层循环
        • eg:
    • 生成器(generator)
      • 生成器是一个对象 ,类似于链表,保存所生成“列表”的某个值
      • 可迭代
      • 本身不能循环,只是可多次yield。迭代时获得yield丢出的值。所以生成器要循环的话必须内置循环。
      • 生成方式:
        • 【 ( f(x) for __ in __ ) 】将列表生成式的方括号改成圆括号
        • 函数:关键字 yield
          • 本质
            • 生成器的本质是按顺序生成一个列表,而且不需同时保存整个列表(迭代访问每次只访问一个,每个只访问一次)
            • 所以某个函数如果自变量是一个整数,返回值可以是列表元素,那么该函数就可以作为一个生成器
          • 实现:将函数返回的return改成yield
            • eg:生成斐波那契的生成器
            • 生成器函数的返回值:pass
          • 调用:g=f()
            • g是生成器
            • f不写参数
      • 访问
        • 用迭代访问生成器 那么其功能等同于列表
        • x=next(g) x是列表元素,每再调用一次x变为下一个元素
      • g.send(x)
        • 生成器是自带的协程工具。它可以在yield处暂停,然后在其他地方的send()处开始切回生成器
        • 所以生成器是等别人的那个函数,死循环,每次consume;而另一个含send的函数是带参的循环体,循环product
        • 两函数的连接是,generator作为参数传入product并在后者内初始化和关闭。
        • generator更像一个“挂件”,负责封装一类功能。而product承担逻辑功能。
        • 如果product不需要改generator的状态,就 yield from取得下一个yield的输出值
        • 将x作为yield的返回值 并且从yield处切入g的内部开始运行。
        • 用g.send(x)初始化生成器时,x必须是None
    • 迭代器(iterator)
      • 迭代器与可迭代的非迭代器对象:
        • 消极/积极
          • 前者消极,是一个数据流。只能被next()调用,仅当需要下一个元素时才产生它
          • 后者积极,储存了一组元素的全部,可以随机访问
        • 迭代操作:
          • 迭代本质是对迭代器的操作,后者在迭代时被隐式转化为迭代器
        • 转化为迭代器:iter() 函数
  • 模块
    • 装有一些函数的.py文件
    • 模块可以避免函数名字冲突
      • 包是一个目录
      • 用以处理同名模块
      • 与普通目录的区别:该目录下要有一个__init__.py文件
        • __init__.py下可以有代码也可以无,它本身也可以是一个模块,模块名是文件名
    • 模块的使用 【import xxx】
      • 导入模块后,会创建名为xxx的变量指向模块,借此访问模块的全部内容(包括函数和变量)
  • 对象编程
    • 名词们
      • 类:抽象模板
      • 实例:具体的一段数据,类的具体化
      • 属性:类内的某个变量
      • 方法:类通用的操作函数
    • 创建类【 class 类名 (继承类) 】
      • 无继承类就继承object 这是所有类都最终继承的
    • 操作类
      • 构造函数
        • __init__(self, *arg ,* kw )
        • self必须有
        • self是实例本身,所以构造要绑属性时:【self. xxx=xxx】
    • 属性
      • 实例的属性除了类内自定的,还可以手工绑定 方式同属性 eg x.a
      • 访问限制
        • 双下划线【__】开头的属性可以避免外部变量访问,基本等同private
          • 实现机制是解释器给他们改名字,所以仍然可以通过改后的名字访问。全凭自觉
        • 形如【__xx__】的属性是特殊变量,可以访问。
    • 继承和多态
      • 继承会获得父类的全部方法和属性
      • 创建和父类同名的方法会覆盖。这种同名不同功的现象叫多态
    • 鸭子法则:pass
    • 获取对象信息
      • 类型判断
        • 【type(x)】返回变量x的类型
        • 【isinstance(x,type)】返回布尔,如果x是type或其子类,返回1
      • 获取属性和方法:【dir(实例或类名)】
        • 返回一个list 包含该实例所属类型的所有实例和方法
    • 动态绑定
      • 动态语言可以给已有的实例或类绑定新的属性或者方法
  • 高级对象
    • 绑定限制 __slots__
      • 这是一个类内定义的特殊属性。
      • 这是一个组,元素为字符串。
      • 组内的字符串是该类允许绑定的属性or方法名
      • 子类不继承slot但是如过子类也有__slots__属性,那么子类允许的名字为自己的和父类的slots
    • 构造函数属性化 @property
      • 1.只读: _name是要属性化的属性名
        • @property
        • def _name(self) :
        • return self._name
      • 2.构造函数属性化: @name.setter
        • @_name.setter
        • def _name(self , value) :
        • 这个函数就相当于构造函数,可以进行参数检查等.
      • @_name.xxx xxx还可是deleter
    • 多重继承 class c (f1,f1,....)
      • c可以继承多个父类的方法和显示属性
      • __init __会继承第一个父类
    • 特殊方法定制
      • 所有的类都有一些内置的方法, 一些被其他函数或语法所调用. 这些方法都能定制化
      • print实例: __str__()
        • 这是一个方法,返回字符串
      • 迭代性质: __iter__(self)__next__(self)
        • 期待一个Iterable时 可迭代对象理应有一个属性 ,是迭代的一个元素 , 然后用next()方法获得下一项.
        • iter返回自己,就是那个有可迭代方法的instance
        • next() 返回下一个元素并且要有结束判断if xxx : ...raise StopIteration()
        • eg .
        • 迭代副作用: pass
      • 函数式调用: __call__(self,*args,**kw)
        • 增加了该方法,可以直接函数式的调用实例x为: x(*args,**kw)
    • 元类 mateclass
      • 类是一种对象,创建类会在后台创建一个对象。元类生成一种类就像修饰器生成一个函数
      • 创建类 type(str_name, tuple, dict)
        • 返回值是类
        • str_name 是类的名字,是个字符串
        • tuple是父类的元组(多重继承,所以可能有多个)
        • dict是绑定的方法 key是创建类的方法名(性质为str),val是要绑上去的函数
  • 错误、调试、测试
    • 错误处理
      • try... except...(except...)else...finally】语句
        • try:当语句块可能出现错误时,将其放入try语句块。
        • 【except 错误类型 as e :】错误类型是从可选项里挑选的;as e指当有错误时,固定写法;冒号后是该类错误的处理方法
      • 错误抛出
        • 由于错误是一种类,所以可以选好继承关系后自定义。
  • IO编程
    • 文件读写
      • 打开文件【open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
        • w写 r读 a追加 +写和读 / b二进制
      • 关闭文件 file object 的方法。 eg >>>f=open("test.txt") >>>f.close()
      • 错误处理 :with open() as f
        • 打开文件失败要报错 try : f=open() finally : if : f f.close()
        • 语法糖:with open() as f 省去了f.c;ose() 以及try finally等步骤
    • StringIO
    • 系统文件和路径操作: os module
      • 文件和目录操作
        • 返回路径: 绝对 os.path.abspath('.')
          • 点是当前目录
        • 列出路径os.listdir(path) 返回list of str
        • 删除 : 路径: os.mkdir(path) 文件 :os.remove(path_of_file)
        • 重命名 os.rename(path_src,path_dst)
          • 文件和路径均可
        • 文件|路径拼接&拆分
          • 拼接 os.path.join(path,paths)
          • 拆分 os.path.split(path) 返回list [0]是head [1]是tail
        • 获取扩展名 os.path.splitext(path) 返回list [0]是前段 [1]是扩展名(含点 eg '.py')
        • 类型判断 os.path.isdir(path) os.path.isfile(path)
        • 文件筛选的例子:
          • [x for x in os.listdir('.') if os.path.isdir(x)] 筛选当前目录下的目录,返回一个list of dir
          • [x for x in os.listdir('.') if os.path.splitext(x)[1] & os.path.isfile(x) ] 筛选当前目录下的.py文件 返回list
      • 环境变量 os.environ
    • 序列化 pass 格式互通 JSON
  • 正则表达式
    • 功能:字符串格式化判断
    • 正则表达式也是字符串 是一种用字符描述字符的方法
    • 语法:子表达式(及其修饰)的连缀
    • 子表达式
      • 单字符 eg a 注意\转义: * . ? + $ ^ [ ] ( ) { } | \ /
      • 范围 [ ] eg[a-z0-9\?:\!] 表示小写字母 数字 ? : ! 中的一个。性质上是单字符
      • 通配字符:
        • \d 数字 =0-9
        • \w 数字字母下划线 =[0-9a-zA-Z_]
        • . 任意字符
        • \s 任意空字符 空格制表符换行分页等
    • 修饰
      • 数量限定
        • 说明了被匹配
        • 位置:修饰在表达式的后面 eg \d+
        • *
        • +
        • ?
        • {n}表示被修饰子表达式重复n次,n非负整
        • {n,} 重复至少n次
        • {n,m}重复至少n至多m次
      • 位置限定
        • 定位符不是字符,而是说明了要匹配字符的位置
        • ^ 位置在被修饰的前方,表示行首
        • $在尾部,表示行位
        • \b单词边界定位 位置:在表达式前表示匹配单词的开头;在表达式后表示匹配词尾
          • eg \bCha 匹配词头为Cha的单词
          • eg ter\b匹配词尾为ter的单词 例如Chapter 但是不匹配determine
        • \B 非边界定位 表示被修饰表达式不在边界处
    • 分界和连接
      • 表达式直接连缀,禁止写空格 因为空格是一个字符
      • 分界:() 括在一起视为一个子表达式
      • 连接: 或运算 | 二元运算符 对象是表达式,结果视为一个表达式,是二者之一
  • 内建模块
  • 异步IO
    • asyncio
      • 协程对象 async def func():它的返回值是协程对象。获取返回时func的调用不会立刻执行函数体,直接返回协程对象
        • async函数内 只可调用异步函数。调用时要await eg. await asyncio.sleep(2)
      • 创建loop对象 loop = asyncio.get_event_loop() 无参
      • 创建任务对象:
        • task : task = loop.creat_task(co) 是loop的方法
        • future: task = asyncio.ensure_future(co) 是不基于loop的方法
      • 运行循环:
        • loop.run_until_complete(task) 是loop的方法,传入task
        • loop.run_until_complete( asyncio.wait(tast_list) ) 传入task_list然后执行
      • 绑定回调
        • task.add_done_callback(func) 绑定回调函数。func是回调函数,参数为task任务对象。task.result()是task的方法,返回task内封装的协程函数的返回值
    • aiohttp
      • 注意await!各种函数都await。实在不行看warning
      • async with aiohttp.ClientSession() as session :异步的取得session对象
      • async with await session.get(url) as response :

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment